Building on the Rust-based process tree killer, this adds a
`killProcessTreeGraceful` async function that implements
SIGTERM → wait → SIGKILL escalation, preventing two issues:

1. Orphaned processes: the tree walker sends signals to all
   descendants regardless of process group, so deep child processes
   (e.g. doppler → bunx → bun → app) all receive SIGTERM.

2. Premature cleanup interruption: the main process now stays alive
   during a configurable grace period (default 5s), keeping the PTY
   master open and preventing the kernel from sending SIGHUP to
   children before they finish their cleanup handlers.

The fire-and-forget `killProcessTree` is kept for synchronous
`process.on('exit')` handlers as a last resort.

Fixes #32438

Co-Authored-By: Claude Opus 4.6 <[email protected]>

- forked-process-task-runner: await kill promises before process.exit()
- running-tasks: per-child SIGINT handlers no longer call process.exit()
  to prevent first-child-exits race
- pseudo-terminal: shutdown() uses sync killProcessTree for exit handler
- pseudo-terminal: kill() uses killProcessTreeGraceful directly
- process_killer: graceful kill detects reparented descendants

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Co-Authored-By: Claude Opus 4.6 <[email protected]>

TaskOrchestrator.cleanup() now awaits the forked process runner's
cleanup promise alongside other running tasks, ensuring all process
trees are fully shut down before the orchestrator continues.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

…reeGraceful

Tests cover:
- Killing a simple process
- Killing a multi-level process tree (parent + children)
- Graceful SIGTERM with cleanup handler verification
- Slow cleanup within grace period (verifies process isn't killed prematurely)
- Multi-level tree graceful shutdown
- Already-dead process (no-op fast path)

Skipped on Windows where Unix signals don't apply.

Co-Authored-By: Claude Opus 4.6 <[email protected]>

Rewrite killProcessTreeGraceful to signal leaf processes first, wait
for them to exit, then signal their parents (now leaves). Keeps the
PTY shell alive while descendants run cleanup handlers.

- Signal only new leaves each iteration (signaled HashSet prevents
  duplicate SIGTERMs that interrupted execSync cleanup)
- Reuse single System instance and Vec buffer across iterations
- Defensive SIGKILL on !has_leaves to prevent process leaks
- Accept string | number signal type (consistent with killProcessTree)
- Add ?. null check in SeriallyRunningTasks.kill()
- Add missing signalToCode import in forked-process-task-runner

Rust:
- Log JoinError instead of silently swallowing with .ok()
- Inline collect_process_tree_inner, drop unused require_root param
- Remove duplicate buf copy before ProcessesToUpdate::Some

Tests:
- Fix SIGTERM test to use single node process (bottom-up kills shell
  children first, preventing trap from firing)
- Fix tree test to poll for marker file instead of silently skipping
  grandchild assertion
- Remove misleading graceful tree test (cleanup marker never written
  due to bottom-up kill order)
- Add SIGKILL fallback test for SIGTERM-ignoring processes
- Add afterEach cleanup, remove unused imports, widen timing bounds

- Early-return in collect_process_tree when root PID not found, skipping unnecessary process table iteration
- Return children map from collect_process_tree to avoid redundant reconstruction in graceful kill path
- Replace duck-typed .then check with Promise.resolve() wrapper in signal handler

…hutdown

Orchestrator is now the single authority for signal dispatch in the
direct-execution path. Children spawned with detached process groups
(setsid) don't receive OS SIGINT; the orchestrator sends SIGTERM via
killProcessTreeGraceful during cleanup.

- exec() -> spawn(detached) in RunningNodeProcess for process group isolation
- Guard per-child signal handlers with NX_FORKED_TASK_EXECUTOR (direct path
  delegates to orchestrator, forked path keeps handlers as primary mechanism)
- Remove FPTR SIGTERM/SIGHUP handlers that consumed events before orchestrator
- Remove FPTR SIGINT process.exit() (orchestrator owns exit decision)
- Unify orchestrator signal handlers via handleSignal with process.on() to
  absorb signal-exit v3 re-raises, stopRequested as re-entrancy guard
- Deduplicate kills between continuousSnapshot and runningRunCommandsTasks
- Add killing flag and closedPromise to RunningNodeProcess for idempotent
  graceful shutdown with stdio drain
- Rust: unified map_signal across platforms, force_kill_fallback for
  fire-and-forget killProcessTree, cleanup subprocess discovery,
  ProcessesToUpdate::All for tracking children spawned during shutdown
- Windows: detached=false (children share console, get CTRL_C_EVENT),
  unsupported signals fall back to SIGKILL via force_kill_fallback

cleanUpUnneededContinuousTasks() fires kill() without await. With the
boolean `killing` flag, cleanup() at the end of run() would call kill()
again but no-op (flag already set), leaving the async kill unwaited.
Detached children survive the parent's exit.

Replace the boolean with a cached killPromise. Concurrent callers
(cleanup after fire-and-forget kill) now await the same in-progress
operation.